Transport providers can be configured in 3 ways -

1. Using an endpoint Uri that defines the scheme and connection information for the transport, such as tcp://localhost:12345. See Mule Endpoint URIs for more information. The URI consists of the protocol followed by transport specific information and then zero or more parameters to set as properties on the connector.
2. Defining a connector configuration in Mule xml, Spring or any other supported configuration.
3. Transport provider properties can be set on endpoints to customise the transport behaviour for a single endpoint instance.

The actual configuration parameters for each transport type are described in the Transports Guide for each particular transport. The following describes the common properties for all transports.

Standard Connector Properties

For information about specific properties for a particular transport provider see the Transports Guide.

Connection Strategies

Connection strategies are used to configure how a connector behaves when it connection fails. Different strategies can be used to control how a reconnection is made based on reties, frequency, exceptions occurred or other factors such as only allowing a reconnect from Jmx.
A connection Strategy is configured on the connector using the <connection-strategy> element. When a <connection-strategy> element is added to a connector the strategy is applied to inbound and outbound connections. If you require different behaviour for inbound and outbound connections on the same connector you need to configure two connectors to handle inbound and outbound connections differently. For example, to configure a Tcp connector that will try to connect 3 times every 2 seconds if the connection is lost -

<connector name="tcp" className="org.mule.providers.tcp.TcpConnector">
    <connection-strategy className="org.mule.providers.SimpleRetryConnectionStrategy">
        <properties>
             <property name="retryCount" value="3"/>
             <property name="frequency" value="2000"/>
        </properties>
    <connection-strategy/>
</connector>

You can set a default connection strategy for all connectors on a Mule instance by setting the strategy in the <mule-environment-properties> element, i.e.

<mule-environment-properties>
    <connection-strategy className="org.mule.providers.SimpleRetryConnectionStrategy">
        <properties>
             <property name="retryCount" value="3"/>
             <property name="frequency" value="2000"/>
        </properties>
    <connection-strategy/>
</mule-environment-properties>

Customising Connection Strategies

Mule comes with a few basic connection strategies such as the the SimpleRetryConnectionStrategy shown above. However, you may need to implement your own. The UMOConnectionStrategy is an interface with one method -

public void doConnect(UMOConnectable connectable) throws FatalConnectException;

This method should attempt to call connect() on the UMOConnectable object, until the connection works or the connection policy implemented by the custom UMOConnectionStrategy fails. If the connection fails a FatalConnectException should be thrown to tell Mule that it cannot connect. No other exceptions including RuntimeExceptions should be thrown.

Connector Service Descriptors

Each transport has a service descriptor that describes what classes are used to construct the transport. The file is located in META-INF/services/org/mule/providers and the file has the same name as the transport protocol i.e. META-INF/services/org/mule/providers/tcp.

Using the TCP transport provider as an examples the file looks like -

connector=org.mule.providers.tcp.TcpConnector
dispatcher.factory=org.mule.providers.tcp.TcpMessageDispatcherFactory
message.receiver=org.mule.providers.tcp.TcpMessageReceiver
message.adapter=org.mule.providers.tcp.TcpMessageAdapter
inbound.transformer=org.mule.transformers.simple.ByteArrayToString
outbound.transformer=org.mule.transformers.simple.StringToByteArray
endpoint.builder=org.mule.impl.endpoint.SocketEndpointBuilder

When an endpoint URI is processed by Mule, it's service descriptor is located using the endpoint protocol and the descriptor along with the information on the URI are used to create a connector and endpoint instance.

Overriding Service Properties

Each Mule transport has a Connector Service Descriptor for each protocol the transport supports that contains some of the properties listed above. Users can override any of these settings for a particular transports so that it's behaviour can be customised to suit a particular usage. For example the FileConnector reads individual files from a directory, but a developer could write a custom UMOMessageReceiver for the file connector to just read changes from an existing file.

Every connector has a serviceOverrides property which is a Map containing one or more of the service properties listed above. Continuing with the custom File Receiver example, a developer can override the 'message.reciever' Connector Service Descriptor property.

<connector name="myFileConnector" className="org.mule.providers.file.FileConnector">
    <properties>
        ...
        <map name="serviceOverrides">
            <property name="message.receiver" value="com.foo.MyFileReceiver"/>
        </map>
    </properties>
</connector>

Setting Default Connector values

For some transports its easy to set all configuration info for the transport in URI i.e. tcp://localhist:12345. For other transports such as Jms, the developer needs to set lots of configuration parameters to create the connection and it becomes difficult to set these parameters on the URI. One option is to pre-configre all connectors in a configuration file, which is fine for some scenarios, but there is also another option.
Mule allows for default properties to be defined for connectors that will be used in absence of the properties being set directly. The properties themselves are set using the name of the property for the connector pre-pended with the connector protocol. For example, to set a default value for the Jms jndiInitialFactory property -

<environment-properties>
    <property name="jms.jndiInitialFactory"
         value="org.codehaus.activemq.jndi.ActiveMQInitialContextFactory"/>
</environment-properties>

or

MuleManager.getInstance.setProperty("jms.jndiInitialFactory",
    "org.codehaus.activemq.jndi.ActiveMQInitialContextFactory");

These properties can be set on the MuleManager or Client.

For a more complete example see the Mule Cookbook: Configuring Multiple Jms Clients

Writing your own Transport

If you want to implement a custom Transport for Mule see Writing Mule Transport Providers.